class NestedInteger(object):
    def __init__(self, value=None):
        """
        If value is not specified, initializes an empty list.
        Otherwise initializes a single integer equal to value.
        """

    def isInteger(self):
        """
        @return True if this NestedInteger holds a single integer, rather than a nested list.
        :rtype bool
        """

    def add(self, elem):
        """
        Set this NestedInteger to hold a nested list and adds a nested integer elem to it.
        :rtype void
        """

    def setInteger(self, value):
        """
        Set this NestedInteger to hold a single integer equal to value.
        :rtype void
        """

    def getInteger(self):
        """
        @return the single integer that this NestedInteger holds, if it holds a single integer
        Return None if this NestedInteger holds a nested list
        :rtype int
        """

    def getList(self):
        """
        @return the nested list that this NestedInteger holds, if it holds a nested list
        Return None if this NestedInteger holds a single integer
        :rtype List[NestedInteger]
        """


class Solution(object):
    def depthSumInverse(self, nestedList):
        """
        :type nestedList: List[NestedInteger]
        :rtype: int
        """
        self.max_depth = 1

        def search(l, depth):
            self.max_depth = max(self.max_depth, depth)
            for item in l:
                if not item.isInteger():
                    search(item.getList(), depth + 1)

        def search2(l, depth):
            total = 0
            for item in l:
                if item.isInteger():
                    total += (self.max_depth - depth + 1) * item.getInteger()
                else:
                    total += search2(item.getList(), depth + 1)
            return total

        search(nestedList, 1)
        return search2(nestedList, 1)
